{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    !pip install pyglet==1.3.2\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 03. DDPG\n",
    "\n",
    "[T. P. Lillicrap et al., \"Continuous control with deep reinforcement learning.\" arXiv preprint arXiv:1509.02971, 2015.](https://arxiv.org/pdf/1509.02971.pdf)\n",
    "\n",
    "Deep Q Network(DQN)([Mnih et al., 2013;2015](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)) algorithm is combined advances in deep learning with reinforcement learning. However, while DQN solves problems with high-dimentional observation spaces, it can only handle discrete and low-dimentional action spaces because of using greedy policy. For learning in high-dimentional and continous action spaces, the authors combine the actor-critic approach with insights from the recent success of DQN. Deep DPG(DDPG) is based on the deterministic policy gradient(DPG) algorithm ([Silver et al., 2014](http://proceedings.mlr.press/v32/silver14.pdf)). \n",
    "\n",
    "### Deterministic policy gradient\n",
    "The DPG algorithm maintains a parameterized actor function $\\mu(s|\\theta^{\\mu})$ which specifies the current policy by deterministically mapping states to a specific action. The critic $Q(s, a)$ is learned using the Bellman equation as in Q-learning. The actor is updated by following the applying the chain rule to the expected return from the start distribution $J$ with respect to the actor parameters\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\nabla_{\\theta^{\\mu}}J &\\approx E_{s_t\\sim\\rho^\\beta} [\\nabla_{\\theta^{\\mu}} Q(s,a|\\theta^Q)|_{s=s_t, a=\\mu(s_t|\\theta^\\mu)}] \\\\\n",
    "&= E_{s_t\\sim\\rho^\\beta} [\\nabla_{a} Q(s,a|\\theta^Q)|_{s=s_t, a=\\mu(s_t)} \\nabla_{\\theta^{\\mu}} \\mu(s|\\theta^\\mu)|_{s=s_t}]\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "### Replay buffer\n",
    "One challenge when using neural networks for reinforcement learning is that most optimization algorithms assume that **the samples are independently and identically distributed**. When the samples are generated from exploring sequentially in an environment this assumption no longer holds. The authors used a **replay buffer** to address these issues. Transitions were sampled from the environment according to the exploration policy and the tuple $(s_t, a_t, r_t, s_{t+1})$ was stored in the replay buffer. At each timestep the actor and critic are updated by sampling a minibatch uniformly from the buffer. It allows to benefit from learning across a set of **uncorrelated** transitions.\n",
    "\n",
    "### Soft update target network\n",
    "Since the network $(Q(s,a|\\theta^Q)$ being updated is also used in calculating the target value, the Q update is prone to divergence. To avoid this, the authors use **the target network** like DQN, but modified for actor-critic and using **soft target updates**. Target netwokrs is created by copying the actor and critic networks, $Q'(s,a|\\theta^{Q'})$ and $\\mu'(s|\\theta^{\\mu`})$ respectively, that are used for calculating the target values. The weights of these target networks are then updated by having them slowly track the learned networks:\n",
    "\n",
    "$$\n",
    "\\theta' \\leftarrow \\tau \\theta + (1 - \\tau)\\theta' \\ \\ \\ {with} \\ \\tau \\ll 1.\n",
    "$$\n",
    "\n",
    "It greatly improves the stability of learning.\n",
    "\n",
    "### Exploration for continuous action space\n",
    "An advantage of offpolicies algorithms such as DDPG is that we can treat the problem of exploration independently from the learning algorithm. The authors construct an exploration policy $\\mu'$ by adding noise sampled from a noise process $\\mathcal{N}$ to the actor policy\n",
    "\n",
    "$$\n",
    "\\mu'(s_t) = \\mu(s_t|\\theta^{\\mu}_t) + \\mathcal{N}\n",
    "$$\n",
    "\n",
    "$\\mathcal{N}$ can be chosen to suit the environment. The authors used **Ornstein-Uhlenbeck process** to generate temporally correlated exploration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        \"\"\"Initializate.\"\"\"\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        \"\"\"Store the transition in buffer.\"\"\"\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OU Noise\n",
    "**Ornstein-Uhlenbeck** process generates temporally correlated exploration, and it effectively copes with physical control problems of inertia.\n",
    "\n",
    "$$\n",
    "dx_t = \\theta(\\mu - x_t) dt + \\sigma dW_t\n",
    "$$\n",
    "\n",
    "Reference: \n",
    "- [Udacity github](https://github.com/udacity/deep-reinforcement-learning/blob/master/ddpg-pendulum/ddpg_agent.py)\n",
    "- [Wiki](https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OUNoise:\n",
    "    \"\"\"Ornstein-Uhlenbeck process.\n",
    "    Taken from Udacity deep-reinforcement-learning github repository:\n",
    "    https://github.com/udacity/deep-reinforcement-learning/blob/master/\n",
    "    ddpg-pendulum/ddpg_agent.py\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        size: int, \n",
    "        mu: float = 0.0, \n",
    "        theta: float = 0.15, \n",
    "        sigma: float = 0.2,\n",
    "    ):\n",
    "        \"\"\"Initialize parameters and noise process.\"\"\"\n",
    "        self.state = np.float64(0.0)\n",
    "        self.mu = mu * np.ones(size)\n",
    "        self.theta = theta\n",
    "        self.sigma = sigma\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"Reset the internal state (= noise) to mean (mu).\"\"\"\n",
    "        self.state = copy.copy(self.mu)\n",
    "\n",
    "    def sample(self) -> np.ndarray:\n",
    "        \"\"\"Update internal state and return it as a noise sample.\"\"\"\n",
    "        x = self.state\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.array(\n",
    "            [random.random() for _ in range(len(x))]\n",
    "        )\n",
    "        self.state = x + dx\n",
    "        return self.state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use two separated networks for actor and critic. The actor network has three fully connected layers and three non-linearity functions, **ReLU** for hidden layers and **tanh** for the output layer. On the other hand, the critic network has three fully connected layers, but it used two activation functions for hidden layers **ReLU**. Plus, its input sizes of critic network are sum of state sizes and action sizes. One thing to note is that we initialize the final layer's weights and biases so that they are **uniformly distributed.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int,\n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, out_dim)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        action = self.out(x).tanh()\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(\n",
    "        self, state: torch.Tensor, action: torch.Tensor\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DDPG Agent\n",
    "Here is a summary of DDPGAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|\n",
    "|\\_plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDPGAgent:\n",
    "    \"\"\"DDPGAgent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        actor_target (nn.Module): actor model to predict next actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        critic_target (nn.Module): target critic model to predict state values\n",
    "        critic_optimizer (Optimizer): optimizer for training critic\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        noise (OUNoise): noise generator for exploration\n",
    "        device (torch.device): cpu / gpu\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        ou_noise_theta: float,\n",
    "        ou_noise_sigma: float,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = 1e4,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "                \n",
    "        # noise\n",
    "        self.noise = OUNoise(\n",
    "            action_dim,\n",
    "            theta=ou_noise_theta,\n",
    "            sigma=ou_noise_sigma,\n",
    "        )\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
    "        \n",
    "        self.critic = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target.load_state_dict(self.critic.state_dict())\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
    "        \n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "    \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.actor(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).detach().cpu().numpy()\n",
    "        \n",
    "        # add noise for exploration during training\n",
    "        if not self.is_test:\n",
    "            noise = self.noise.sample()\n",
    "            selected_action = np.clip(selected_action + noise, -1.0, 1.0)\n",
    "        \n",
    "        self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        \n",
    "        samples = self.memory.sample_batch()\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        masks = 1 - done\n",
    "        next_action = self.actor_target(next_state)\n",
    "        next_value = self.critic_target(next_state, next_action)\n",
    "        curr_return = reward + self.gamma * next_value * masks\n",
    "        \n",
    "        # train critic\n",
    "        values = self.critic(state, action)\n",
    "        critic_loss = F.mse_loss(values, curr_return)\n",
    "        \n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "                \n",
    "        # train actor\n",
    "        actor_loss = -self.critic(state, self.actor(state)).mean()\n",
    "        \n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        \n",
    "        # target update\n",
    "        self._target_soft_update()\n",
    "        \n",
    "        return actor_loss.data, critic_loss.data\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        actor_losses = []\n",
    "        critic_losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:         \n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size \n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                actor_loss, critic_loss = self.update_model()\n",
    "                actor_losses.append(actor_loss)\n",
    "                critic_losses.append(critic_loss)\n",
    "            \n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(\n",
    "                    self.total_step, \n",
    "                    scores, \n",
    "                    actor_losses, \n",
    "                    critic_losses,\n",
    "                )\n",
    "                \n",
    "        self.env.close()\n",
    "        \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        \n",
    "        for t_param, l_param in zip(\n",
    "            self.actor_target.parameters(), self.actor.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "            \n",
    "        for t_param, l_param in zip(\n",
    "            self.critic_target.parameters(), self.critic.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float], \n",
    "        critic_losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 128\n",
    "ou_noise_theta = 1.0\n",
    "ou_noise_sigma = 0.1\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = DDPGAgent(\n",
    "    env, \n",
    "    memory_size, \n",
    "    batch_size,\n",
    "    ou_noise_theta,\n",
    "    ou_noise_sigma,\n",
    "    initial_random_steps=initial_random_steps\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -233.43761792984384\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgQHJLHBQICUAJLIRH\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderQHJLHBQICUAJLIRH\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animQHJLHBQICUAJLIRH.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQHJLHBQICUAJLIRH.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectQHJLHBQICUAJLIRH\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgQHJLHBQICUAJLIRH\";\n",
       "    var slider_id = \"_anim_sliderQHJLHBQICUAJLIRH\";\n",
       "    var loop_select_id = \"_anim_loop_selectQHJLHBQICUAJLIRH\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animQHJLHBQICUAJLIRH = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
